function mxShape()
{
};
mxShape.prototype.SVG_STROKE_TOLERANCE = 8;
mxShape.prototype.scale = 1;
mxShape.prototype.dialect = null;
mxShape.prototype.mixedModeHtml = true;
mxShape.prototype.preferModeHtml = true;
mxShape.prototype.bounds = null;
mxShape.prototype.points = null;
mxShape.prototype.node = null;
mxShape.prototype.label = null;
mxShape.prototype.innerNode = null;
mxShape.prototype.style = null;
mxShape.prototype.startOffset = null;
mxShape.prototype.endOffset = null;
mxShape.prototype.init = function(container)
{
	if (this.node == null)
	{
		this.node = this.create(container);

		if (container != null)
		{
			container.appendChild(this.node);
		}
	}
	this.redraw();

	if (this.insertGradientNode != null)
	{

		var count = 0;
		var id = this.insertGradientNode.getAttribute('id');
		var gradient = document.getElementById(id);

		while (gradient != null && gradient.ownerSVGElement != this.node.ownerSVGElement)
		{
			count++;
			id = this.insertGradientNode.getAttribute('id') + '-' + count;
			gradient = document.getElementById(id);
		}

		if (gradient == null)
		{
			this.insertGradientNode.setAttribute('id', id);
			this.node.ownerSVGElement.appendChild(this.insertGradientNode);
			gradient = this.insertGradientNode;
		}

		if (gradient != null)
		{
			var tmp = (this.innerNode != null) ? this.innerNode : this.node;

			if (tmp != null)
			{
				tmp.setAttribute('fill', 'url(#' + id + ')');
			}
		}

		if (this.insertGradientNode != null)
		{
			this.insertGradient(this.insertGradientNode);
			this.insertGradientNode = null;
		}
	}
};
mxShape.prototype.insertGradient = function(node)
{
	if (node != null)
	{
		var count = 0;
		var id = node.getAttribute('id');
		var gradient = document.getElementById(id);

		while (gradient != null && gradient.ownerSVGElement != this.node.ownerSVGElement)
		{
			count++;
			id = node.getAttribute('id') + '-' + count;
			gradient = document.getElementById(id);
		}

		if (gradient == null)
		{
			node.setAttribute('id', id);
			this.node.ownerSVGElement.appendChild(node);
			gradient = node;
		}

		if (gradient != null)
		{
			var tmp = (this.innerNode != null) ? this.innerNode : this.node;

			if (tmp != null)
			{
				tmp.setAttribute('fill', 'url(#' + id + ')');
			}
		}
	}
};
mxShape.prototype.isMixedModeHtml = function()
{
	return this.mixedModeHtml && !this.isRounded && !this.isShadow && this.gradient == null;
};
mxShape.prototype.create = function(container)
{
	var node = null;

	if (this.dialect == mxConstants.DIALECT_SVG)
	{
		node = this.createSvg();
	}
	else if (this.dialect == mxConstants.DIALECT_STRICTHTML
		|| (this.preferModeHtml && this.dialect == mxConstants.DIALECT_PREFERHTML)
		|| (this.isMixedModeHtml() && this.dialect == mxConstants.DIALECT_MIXEDHTML))
	{
		node = this.createHtml();
	}
	else
	{
		node = this.createVml();
	}
	return node;
};
mxShape.prototype.createHtml = function()
{
	var node = document.createElement('DIV');
	this.configureHtmlShape(node);
	return node;
};
mxShape.prototype.destroy = function()
{
	if (this.node != null)
	{
		mxEvent.release(this.node);

		if (this.node.parentNode != null)
		{
			this.node.parentNode.removeChild(this.node);
		}
		this.node = null;
	}
};
mxShape.prototype.apply = function(state)
{
	var style = state.style;
	this.style = style;

	if (style != null)
	{
		this.fill = mxUtils.getValue(style, mxConstants.STYLE_FILLCOLOR, this.fill);
		this.gradient = mxUtils.getValue(style, mxConstants.STYLE_GRADIENTCOLOR, this.gradient);
		this.gradientDirection = mxUtils.getValue(style, mxConstants.STYLE_GRADIENT_DIRECTION, this.gradientDirection);
		this.opacity = mxUtils.getValue(style, mxConstants.STYLE_OPACITY, this.opacity);
		this.stroke = mxUtils.getValue(style, mxConstants.STYLE_STROKECOLOR, this.stroke);
		this.strokewidth = mxUtils.getValue(style, mxConstants.STYLE_STROKEWIDTH, this.strokewidth);
		this.isShadow = mxUtils.getValue(style, mxConstants.STYLE_SHADOW, this.isShadow);
		this.isDashed = mxUtils.getValue(style, mxConstants.STYLE_DASHED, this.isDashed);
		this.spacing = mxUtils.getValue(style, mxConstants.STYLE_SPACING, this.spacing);
		this.startSize = mxUtils.getValue(style, mxConstants.STYLE_STARTSIZE, this.startSize);
		this.endSize = mxUtils.getValue(style, mxConstants.STYLE_ENDSIZE, this.endSize);
		this.isRounded = mxUtils.getValue(style, mxConstants.STYLE_ROUNDED, this.isRounded);
		this.startArrow = mxUtils.getValue(style, mxConstants.STYLE_STARTARROW, this.startArrow);
		this.endArrow = mxUtils.getValue(style, mxConstants.STYLE_ENDARROW, this.endArrow);
		this.rotation = mxUtils.getValue(style, mxConstants.STYLE_ROTATION, this.rotation);
	}
};
mxShape.prototype.createSvgGroup = function(shape)
{
	var g = document.createElementNS(mxConstants.NS_SVG, 'g');
	this.innerNode = document.createElementNS(mxConstants.NS_SVG, shape);
	this.configureSvgShape(this.innerNode);
	this.shadowNode = this.createSvgShadow(this.innerNode);

	if (this.shadowNode != null)
	{
		g.appendChild(this.shadowNode);
	}
	g.appendChild(this.innerNode);
	return g;
};
mxShape.prototype.createSvgShadow = function(node)
{
	if (this.isShadow && this.fill != null)
	{
		var shadow = node.cloneNode(true);
		shadow.setAttribute('stroke', mxConstants.SVG_SHADOWCOLOR);
		shadow.setAttribute('fill', mxConstants.SVG_SHADOWCOLOR);
		shadow.setAttribute('transform', mxConstants.SVG_SHADOWTRANSFORM);
		return shadow;
	}
	return null;
};
mxShape.prototype.configureHtmlShape = function(node)
{
	if (mxUtils.isVml(node))
	{
		this.configureVmlShape(node);
	}
	else
	{
		node.style.position = 'absolute';
		node.style.overflow = 'hidden';
		var color = this.stroke;

		if (color != null)
		{
			node.style.borderColor = color;
		}

		if (this.isDashed)
		{
			node.style.borderStyle = 'dashed';
		}
		else if (this.strokewidth > 0)
		{
			node.style.borderStyle = 'solid';
		}
		node.style.borderWidth = this.strokewidth + 'px';
		color = this.fill;

		if (color != null)
		{
			node.style.backgroundColor = color;
		}
		else
		{
			node.style.background = 'url(\'' + mxClient.imageBasePath + 'transparent.gif\')';
		}

		if (this.opacity != null)
		{
			mxUtils.setOpacity(node, this.opacity);
		}
	}
};
mxShape.prototype.configureVmlShape = function(node)
{
	node.style.position = 'absolute';
	var color = this.stroke;

	if (color != null)
	{
		node.setAttribute('strokecolor', color);
	}
	else
	{
		node.setAttribute('stroked', 'false');
	}
	color = this.fill;

	if (color != null)
	{
		node.setAttribute('fillcolor', color);

		if (node.fillNode == null)
		{
			node.fillNode = document.createElement('v:fill');
			node.appendChild(node.fillNode);
		}
		node.fillNode.setAttribute('color', color);

		if (this.gradient != null)
		{
			node.fillNode.setAttribute('type', 'gradient');
			node.fillNode.setAttribute('color2', this.gradient);
			var angle = '180';

			if (this.gradientDirection == mxConstants.DIRECTION_EAST)
			{
				angle = '270';
			}
			else if (this.gradientDirection == mxConstants.DIRECTION_WEST)
			{
				angle = '90';
			}
			else if (this.gradientDirection == mxConstants.DIRECTION_NORTH)
			{
				angle = '0';
			}
			node.fillNode.setAttribute('angle', angle);
		}

		if (this.opacity != null)
		{
			node.fillNode.setAttribute('opacity', this.opacity + '%');

			if (this.gradient != null)
			{
				node.fillNode.setAttribute('o:opacity2', this.opacity + '%');
			}
		}
	}
	else
	{
		node.setAttribute('filled', 'false');

		if (node.fillNode != null)
		{
			mxEvent.release(node.fillNode);
			node.removeChild(node.fillNode);
			node.fillNode = null;
		}
	}

	if ((this.isDashed || this.opacity != null) && this.strokeNode == null)
	{
		this.strokeNode = document.createElement('v:stroke');
		node.appendChild(this.strokeNode);
	}

	if (this.strokeNode != null)
	{
		if (this.isDashed)
		{
			this.strokeNode.setAttribute('dashstyle', '2 2');
		}
		else
		{
			this.strokeNode.setAttribute('dashstyle', 'solid');
		}

		if (this.opacity != null)
		{
			this.strokeNode.setAttribute('opacity', this.opacity + '%');
		}
	}

	if (this.isShadow && this.fill != null)
	{
		if (this.shadowNode == null)
		{
			this.shadowNode = document.createElement('v:shadow');
			this.shadowNode.setAttribute('on', 'true');
			node.appendChild(this.shadowNode);
		}
	}

	if (node.nodeName == 'roundrect')
	{
		try
		{
			node.setAttribute('arcsize', String(mxConstants.RECTANGLE_ROUNDING_FACTOR * 100) + '%');
		}
		catch (e)
		{
		}
	}
}
mxShape.prototype.configureSvgShape = function(node)
{
	var color = this.stroke;

	if (color != null)
	{
		node.setAttribute('stroke', color);
	}
	else
	{
		node.setAttribute('stroke', 'none');
	}
	color = this.fill;

	if (color != null)
	{
		if (this.gradient != null)
		{
			var id = this.getGradientId(color, this.gradient, this.opacity);

			if (this.gradientNode != null && this.gradientNode.getAttribute('id') != id)
			{
				this.gradientNode = null;
				node.setAttribute('fill', '');
			}

			if (this.gradientNode == null)
			{
				this.gradientNode = this.createSvgGradient(id, color, this.gradient, this.opacity, node);
				node.setAttribute('fill', 'url(#' + id + ')');
			}
		}
		else
		{

			this.gradientNode = null;
			node.setAttribute('fill', color);
		}
	}
	else
	{
		node.setAttribute('fill', 'none');
	}

	if (this.isDashed)
	{
		node.setAttribute('stroke-dasharray', '3, 3');
	}

	if (this.opacity != null)
	{
		node.setAttribute('fill-opacity', this.opacity / 100);
		node.setAttribute('stroke-opacity', this.opacity / 100);
	}
};
mxShape.prototype.getGradientId = function(start, end, opacity)
{
	var op = (opacity != null) ? opacity : 100;
	var dir = null;

	if (this.gradientDirection == null || this.gradientDirection == mxConstants.DIRECTION_SOUTH)
	{
		dir = 'south';
	}
	else if (this.gradientDirection == mxConstants.DIRECTION_EAST)
	{
		dir = 'east';
	}
	else if (this.gradientDirection == mxConstants.DIRECTION_NORTH)
	{
		dir = 'north';
	}
	else if (this.gradientDirection == mxConstants.DIRECTION_WEST)
	{
		dir = 'west';
	}
	return 'mxGradient-' + start + '-' + end + '-' + op + '-' + dir;
};
mxShape.prototype.createSvgGradient = function(id, start, end, opacity, node)
{
	var op = (opacity != null) ? opacity : 100;
	var gradient = this.insertGradientNode;

	if (gradient == null)
	{
		var gradient = document.createElementNS(mxConstants.NS_SVG, 'linearGradient');
		gradient.setAttribute('id', id);
		gradient.setAttribute('x1', '0%');
		gradient.setAttribute('y1', '0%');
		gradient.setAttribute('x2', '0%');
		gradient.setAttribute('y2', '0%');

		if (this.gradientDirection == null || this.gradientDirection == mxConstants.DIRECTION_SOUTH)
		{
			gradient.setAttribute('y2', '100%');
		}
		else if (this.gradientDirection == mxConstants.DIRECTION_EAST)
		{
			gradient.setAttribute('x2', '100%');
		}
		else if (this.gradientDirection == mxConstants.DIRECTION_NORTH)
		{
			gradient.setAttribute('y1', '100%');
		}
		else if (this.gradientDirection == mxConstants.DIRECTION_WEST)
		{
			gradient.setAttribute('x1', '100%');
		}
		var stop = document.createElementNS(mxConstants.NS_SVG, 'stop');
		stop.setAttribute('offset', '0%');
		stop.setAttribute('style', 'stop-color:' + start + ';stop-opacity:' + (op / 100));
		gradient.appendChild(stop);
		stop = document.createElementNS(mxConstants.NS_SVG, 'stop');
		stop.setAttribute('offset', '100%');
		stop.setAttribute('style', 'stop-color:' + end + ';stop-opacity:' + (op / 100));
		gradient.appendChild(stop);
	}

	this.insertGradientNode = gradient;
	return gradient;
};
mxShape.prototype.createPoints = function(moveCmd, lineCmd, curveCmd, isRelative)
{
	var offsetX = (isRelative) ? this.bounds.x : 0;
	var offsetY = (isRelative) ? this.bounds.y : 0;
	var size = mxConstants.LINE_ARCSIZE * this.scale;
	var points =
		moveCmd + ' ' + Math.floor(this.points[0].x - offsetX) + ' ' + Math.floor(this.points[0].y - offsetY) + ' ';

	for (var i = 1; i < this.points.length; i++)
	{
		var pt = this.points[i];
		var p0 = this.points[i - 1];

		if (isNaN(pt.x) || isNaN(pt.y))
		{
			return null;
		}

		if (i == 1 && this.startOffset != null)
		{
			p0 = p0.clone();
			p0.x += this.startOffset.x;
			p0.y += this.startOffset.y;
		}
		else if (i == this.points.length - 1 && this.endOffset != null)
		{
			pt = pt.clone();
			pt.x += this.endOffset.x;
			pt.y += this.endOffset.y;
		}
		var dx = p0.x - pt.x;
		var dy = p0.y - pt.y;

		if ((this.isRounded && i < this.points.length - 1) && (dx != 0 || dy != 0) && this.scale > 0.3)
		{

			var dist = Math.sqrt(dx * dx + dy * dy);
			var nx1 = dx * Math.min(size, dist / 2) / dist;
			var ny1 = dy * Math.min(size, dist / 2) / dist;
			points += lineCmd + ' ' + Math.floor(pt.x + nx1 - offsetX) + ' ' + Math.floor(pt.y + ny1 - offsetY) + ' ';

			var pe = this.points[i + 1];
			dx = pe.x - pt.x;
			dy = pe.y - pt.y;
			dist = Math.max(1, Math.sqrt(dx * dx + dy * dy));
			var nx2 = dx * Math.min(size, dist / 2) / dist;
			var ny2 = dy * Math.min(size, dist / 2) / dist;
			points += curveCmd + ' ' + Math.floor(pt.x - offsetX) + ' ' + Math.floor(pt.y - offsetY) + ' '
				+ Math.floor(pt.x - offsetX) + ',' + Math.floor(pt.y - offsetY) + ' ' + Math.floor(pt.x + nx2 - offsetX)
				+ ' ' + Math.floor(pt.y + ny2 - offsetY) + ' ';
		}
		else
		{
			points += lineCmd + ' ' + Math.floor(pt.x - offsetX) + ' ' + Math.floor(pt.y - offsetY) + ' ';
		}
	}
	return points;
};
mxShape.prototype.updateHtmlShape = function(node)
{
	if (node != null)
	{
		if (mxUtils.isVml(node))
		{
			this.updateVmlShape(node);
		}
		else
		{
			node.style.borderWidth = Math.max(1, Math.floor(this.strokewidth * this.scale)) + 'px';

			if (this.bounds != null)
			{
				node.style.left = Math.floor(this.bounds.x) + 'px';
				node.style.top = Math.floor(this.bounds.y) + 'px';
				node.style.width = Math.floor(this.bounds.width) + 'px';
				node.style.height = Math.floor(this.bounds.height) + 'px';
			}
		}

		if (this.points != null && this.bounds != null && !mxUtils.isVml(node))
		{
			if (this.divContainer == null)
			{
				this.divContainer = document.createElement('div');
				node.appendChild(this.divContainer);
			}
			node.style.borderStyle = 'none';

			while (this.divContainer.firstChild != null)
			{
				mxEvent.release(this.divContainer.firstChild);
				this.divContainer.removeChild(this.divContainer.firstChild);
			}

			if (this.points.length == 2)
			{
				var p0 = this.points[0];
				var pe = this.points[1];
				var dx = pe.x - p0.x;
				var dy = pe.y - p0.y;

				if (dx == 0 || dy == 0)
				{
					node.style.borderStyle = 'solid';
				}
				else
				{
					node.style.width = Math.floor(this.bounds.width + 1) + 'px';
					node.style.height = Math.floor(this.bounds.height + 1) + 'px';
					var length = Math.sqrt(dx * dx + dy * dy);
					var dotCount = 1 + (length / (20 * this.scale));
					var nx = dx / dotCount;
					var ny = dy / dotCount;
					var x = p0.x - this.bounds.x;
					var y = p0.y - this.bounds.y;

					for (var i = 0; i < dotCount; i++)
					{
						var tmp = document.createElement('DIV');
						tmp.style.position = 'absolute';
						tmp.style.overflow = 'hidden';
						tmp.style.left = Math.floor(x) + 'px';
						tmp.style.top = Math.floor(y) + 'px';
						tmp.style.width = Math.max(1, 2 * this.scale) + 'px';
						tmp.style.height = Math.max(1, 2 * this.scale) + 'px';
						tmp.style.backgroundColor = this.stroke;
						this.divContainer.appendChild(tmp);
						x += nx;
						y += ny;
					}
				}
			}
			else if (this.points.length == 3)
			{
				var mid = this.points[1];
				var n = '0';
				var s = '1';
				var w = '0';
				var e = '1';

				if (mid.x == this.bounds.x)
				{
					e = '0';
					w = '1';
				}

				if (mid.y == this.bounds.y)
				{
					n = '1';
					s = '0';
				}
				node.style.borderStyle = 'solid';
				node.style.borderWidth = n + ' ' + e + ' ' + s + ' ' + w + 'px';
			}
			else
			{
				node.style.width = Math.floor(this.bounds.width + 1) + 'px';
				node.style.height = Math.floor(this.bounds.height + 1) + 'px';
				var last = this.points[0];

				for (var i = 1; i < this.points.length; i++)
				{
					var next = this.points[i];
					var tmp = document.createElement('DIV');
					tmp.style.position = 'absolute';
					tmp.style.overflow = 'hidden';
					tmp.style.borderColor = this.stroke;
					tmp.style.borderStyle = 'solid';
					tmp.style.borderWidth = '1 0 0 1px';
					var x = Math.min(next.x, last.x) - this.bounds.x;
					var y = Math.min(next.y, last.y) - this.bounds.y;
					var w = Math.max(1, Math.abs(next.x - last.x));
					var h = Math.max(1, Math.abs(next.y - last.y));
					tmp.style.left = x + 'px';
					tmp.style.top = y + 'px';
					tmp.style.width = w + 'px';
					tmp.style.height = h + 'px';
					this.divContainer.appendChild(tmp);
					last = next;
				}
			}
		}
	}
};
mxShape.prototype.updateVmlShape = function(node)
{
	node.setAttribute('strokeweight', this.strokewidth * this.scale);

	if (this.bounds != null)
	{
		node.style.left = Math.floor(this.bounds.x) + 'px';
		node.style.top = Math.floor(this.bounds.y) + 'px';
		node.style.width = Math.floor(this.bounds.width) + 'px';
		node.style.height = Math.floor(this.bounds.height) + 'px';

		if (this.points == null)
		{
			if (this.rotation != null && this.rotation != 0)
			{
				node.style.rotation = this.rotation;
			}
			else if (node.style.rotation != null)
			{
				node.style.rotation = '';
			}
		}
	}

	if (this.points != null)
	{
		if (node.nodeName == 'polyline' && node.points != null)
		{
			var points = '';

			for (var i = 0; i < this.points.length; i++)
			{
				points += this.points[i].x + ',' + this.points[i].y + ' ';
			}
			node.points.value = points;
			node.style.left = null;
			node.style.top = null;
			node.style.width = null;
			node.style.height = null;
		}
		else if (this.bounds != null)
		{
			this.node.setAttribute('coordsize', Math.floor(this.bounds.width) + ',' + Math.floor(this.bounds.height));
			var points = this.createPoints('m', 'l', 'c', true);

			{
				{
				}
			}
			node.setAttribute('path', points + ' e');
		}
	}
};
mxShape.prototype.updateSvgShape = function(node)
{
	var strokeWidth = Math.max(1, this.strokewidth * this.scale);
	node.setAttribute('stroke-width', strokeWidth);

	if (this.points != null && this.points[0] != null)
	{
		var d = this.createPoints('M', 'L', 'C', false);

		if (d != null)
		{
			node.setAttribute('d', d);

			{
				{
				}
			}

			node.removeAttribute('x');
			node.removeAttribute('y');
			node.removeAttribute('width');
			node.removeAttribute('height');
		}
	}
	else if (this.bounds != null)
	{
		node.setAttribute('x', this.bounds.x);
		node.setAttribute('y', this.bounds.y);
		var w = this.bounds.width;
		var h = this.bounds.height;
		node.setAttribute('width', w);
		node.setAttribute('height', h);

		if (this.isRounded)
		{
			var r = Math.min(w * mxConstants.RECTANGLE_ROUNDING_FACTOR, h * mxConstants.RECTANGLE_ROUNDING_FACTOR);
			node.setAttribute('rx', r);
			node.setAttribute('ry', r);
		}
		this.updateSvgTransform(node, node == this.shadowNode);
	}
};
mxShape.prototype.updateSvgTransform = function(node, shadow)
{
	if (this.rotation != null && this.rotation != 0)
	{
		var cx = this.bounds.x + this.bounds.width / 2;
		var cy = this.bounds.y + this.bounds.height / 2;

		if (shadow)
		{
			node.setAttribute('transform',
				'rotate(' + this.rotation + ',' + cx + ',' + cy + ') ' + mxConstants.SVG_SHADOWTRANSFORM);
		}
		else
		{
			node.setAttribute('transform', 'rotate(' + this.rotation + ',' + cx + ',' + cy + ')');
		}
	}
	else
	{
		if (shadow)
		{
			node.setAttribute('transform', mxConstants.SVG_SHADOWTRANSFORM);
		}
		else
		{
			node.removeAttribute('transform');
		}
	}
};
mxShape.prototype.reconfigure = function()
{
	if (this.dialect == mxConstants.DIALECT_SVG)
	{
		if (this.innerNode != null)
		{
			this.configureSvgShape(this.innerNode);
		}
		else
		{
			this.configureSvgShape(this.node);
		}

		if (this.insertGradientNode != null)
		{
			this.insertGradient(this.insertGradientNode);
			this.insertGradientNode = null;
		}
	}
	else if (mxUtils.isVml(this.node))
	{
		this.configureVmlShape(this.node);
	}
	else
	{
		this.configureHtmlShape(this.node);
	}
};
mxShape.prototype.redraw = function()
{
	if (this.dialect == mxConstants.DIALECT_SVG)
	{
		this.redrawSvg();
	}
	else if (mxUtils.isVml(this.node))
	{
		this.redrawVml();
	}
	else
	{
		this.redrawHtml();
	}
};
mxShape.prototype.redrawSvg = function()
{
	if (this.innerNode != null)
	{
		this.updateSvgShape(this.innerNode);

		if (this.shadowNode != null)
		{
			this.updateSvgShape(this.shadowNode);
		}
	}
	else
	{
		this.updateSvgShape(this.node);
	}
};
mxShape.prototype.redrawVml = function()
{
	this.updateVmlShape(this.node);
};
mxShape.prototype.redrawHtml = function()
{
	this.updateHtmlShape(this.node);
};
mxShape.prototype.createPath = function(arg)
{
	var x = this.bounds.x;
	var y = this.bounds.y;
	var w = this.bounds.width;
	var h = this.bounds.height;
	var path = null;

	if (this.dialect == mxConstants.DIALECT_SVG)
	{
		path = new mxPath('svg');
		path.setTranslate(x, y);
	}
	else
	{
		path = new mxPath('vml');
	}
	this.redrawPath(path, x, y, w, h, arg);
	return path.getPath();
};
mxShape.prototype.redrawPath = function(path, x, y, w, h)
{
};